package com.fjnu.fjnu_grade_demo.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.fjnu.fjnu_grade_demo.factory.LambdaQueryWrapperFactory;
import com.fjnu.fjnu_grade_demo.mapper.StudentCourseGradeMapper;
import com.fjnu.fjnu_grade_demo.mapper.StudentMapper;
import com.fjnu.fjnu_grade_demo.mapper.StudentTotalGradeMapper;
import com.fjnu.fjnu_grade_demo.moudle.SingleGradeRankMoudle;
import com.fjnu.fjnu_grade_demo.moudle.TotalGradeRankMoudle;
import com.fjnu.fjnu_grade_demo.moudle.entity.Student;
import com.fjnu.fjnu_grade_demo.moudle.entity.StudentCourseGrade;
import com.fjnu.fjnu_grade_demo.moudle.entity.StudentTotalGrade;
import com.fjnu.fjnu_grade_demo.service.IAdminService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class AdminServiceImpl extends ServiceImpl<StudentCourseGradeMapper, StudentCourseGrade>
        implements IAdminService {

    @Autowired
    private StudentTotalGradeMapper studentTotalGradeMapper;
    @Autowired
    private StudentCourseGradeMapper studentCourseGradeMapper;
    @Autowired
    private StudentMapper studentMapper;

    /**
     * 获取学生的总成绩排名
     *
     * 此方法通过查询学生总成绩表，根据平均绩点排名（AvgGpaRank）降序获取所有学生的成绩信息，
     * 并将这些信息映射到TotalGradeRankMoudle对象中，以便于展示层或其他服务层使用
     *
     * @return 包含学生姓名、平均绩点排名和平均绩点的TotalGradeRankMoudle对象列表
     */
    @Override
    public List<TotalGradeRankMoudle> getTotalStudentGradeRank() {
        // 创建一个针对StudentTotalGrade类的Lambda查询包装器，用于后续的查询操作
        LambdaQueryWrapper<StudentTotalGrade> totalGradeLambdaQueryWrapper = LambdaQueryWrapperFactory
                .getLambdaQueryWrapper(StudentTotalGrade.class);

        // 设置查询条件，根据平均绩点排名升序排序
        totalGradeLambdaQueryWrapper.orderByAsc(StudentTotalGrade::getAvgGpaRank);

        // 执行查询，获取所有学生的总成绩信息
        List<StudentTotalGrade> studentTotalGrade2s = studentTotalGradeMapper
                .selectList(totalGradeLambdaQueryWrapper);

        // 将查询结果转换为TotalGradeRankMoudle对象列表，便于后续处理和展示
        List<TotalGradeRankMoudle> totalGradeRankMoudles = new ArrayList<>();
        for (StudentTotalGrade studentTotalGrade2 : studentTotalGrade2s) {
            TotalGradeRankMoudle totalGradeRankMoudle = new TotalGradeRankMoudle();
            totalGradeRankMoudle.setUserName(studentTotalGrade2.getUserName());
            totalGradeRankMoudle.setAvgGpaRank(studentTotalGrade2.getAvgGpaRank());
            totalGradeRankMoudle.setAvgGpa(studentTotalGrade2.getAvgGpa());
            totalGradeRankMoudles.add(totalGradeRankMoudle);
        }

        // 返回转换后的学生总成绩排名列表
        return totalGradeRankMoudles;
    }

    /**
     * 获取指定课程的成绩排名列表。
     *
     * @param courseName 课程名称，用于筛选特定课程的成绩数据。
     * @return 返回一个包含单课程成绩排名信息的列表，每个元素为 SingleGradeRankMoudle 对象。
     */
    @Override
    public List<SingleGradeRankMoudle> getSingleCourseGradeRank(String courseName) {
        // 构建查询条件，筛选指定课程并按 GPA 排名升序排序
        LambdaQueryWrapper<StudentCourseGrade> studentCourseGradeLambdaQueryWrapper = LambdaQueryWrapperFactory
                .getLambdaQueryWrapper(StudentCourseGrade.class);
        studentCourseGradeLambdaQueryWrapper
                .eq(StudentCourseGrade::getCourseName, courseName)
                .orderByAsc(StudentCourseGrade::getGpaRank);

        // 查询符合条件的学生课程成绩数据
        List<StudentCourseGrade> studentCourseGrade2s = studentCourseGradeMapper
                .selectList(studentCourseGradeLambdaQueryWrapper);

        // 将查询结果转换为 SingleGradeRankMoudle 列表
        List<SingleGradeRankMoudle> singleGradeRankMoudles = new ArrayList<>();
        for (StudentCourseGrade studentCourseGrade2 : studentCourseGrade2s) {
            SingleGradeRankMoudle singleGradeRankMoudle = new SingleGradeRankMoudle();
            singleGradeRankMoudle.setCourseName(studentCourseGrade2.getCourseName());
            singleGradeRankMoudle.setUserName(studentCourseGrade2.getUserName());
            singleGradeRankMoudle.setHighestScore(studentCourseGrade2.getHighestScore());
            singleGradeRankMoudle.setGpaRank(studentCourseGrade2.getGpaRank());
            singleGradeRankMoudle.setGpa(studentCourseGrade2.getGpa());
            singleGradeRankMoudles.add(singleGradeRankMoudle);
        }
        return singleGradeRankMoudles;
    }

    /**
     * 删除指定学生的信息。
     *
     * @param studentId 学生 ID，用于定位需要删除的学生记录。
     * @return 返回操作结果，删除成功返回 "删除成功"，否则返回 "删除失败"。
     */
    @Override
    public String deleteStudentMessage(String studentId) {
        return studentMapper.deleteById(studentId) > 0 ? "删除成功" : "删除失败";
    }

    /**
     * 获取指定学生的总成绩排名信息。
     *
     * @param studentId 学生 ID，用于定位特定学生的总成绩数据。
     * @return 返回一个包含总成绩排名信息的 TotalGradeRankMoudle 对象。
     */
    @Override
    public StudentTotalGrade getOneTotalGradeRank(String studentId,String academicYear,String semester) {
        // 构建查询条件，筛选指定学生 ID 的总成绩数据
        LambdaQueryWrapper<StudentTotalGrade> studentTotalGradeLambdaQueryWrapper = LambdaQueryWrapperFactory
                .getLambdaQueryWrapper(StudentTotalGrade.class);
        StudentTotalGrade studentTotalGrade2 = studentTotalGradeMapper
                .selectOne(studentTotalGradeLambdaQueryWrapper.eq(StudentTotalGrade::getStudentId, studentId)
                        .eq(StudentTotalGrade::getAcademicYear, academicYear)
                        .eq(StudentTotalGrade::getSemester, semester));

        return studentTotalGrade2;
    }

    /**
     * 获取指定学生在某课程中的成绩排名信息。
     *
     * @param studentId   学生 ID，用于定位特定学生。
     * @param courseName 课程名称，用于定位特定课程。
     * @return 返回一个包含单课程成绩排名信息的 SingleGradeRankMoudle 对象。
     */
    @Override
    public SingleGradeRankMoudle getOneSingleGradeRank(String studentId, String courseName) {
        // 构建查询条件，筛选指定学生和课程的成绩数据
        LambdaQueryWrapper<StudentCourseGrade> studentCourseGradeLambdaQueryWrapper = LambdaQueryWrapperFactory
                .getLambdaQueryWrapper(StudentCourseGrade.class);
        StudentCourseGrade studentCourseGrade2 = studentCourseGradeMapper
                .selectOne(studentCourseGradeLambdaQueryWrapper
                        .eq(StudentCourseGrade::getStudentId, studentId)
                        .eq(StudentCourseGrade::getCourseName, courseName));

        // 将查询结果封装为 SingleGradeRankMoudle 对象
        SingleGradeRankMoudle singleGradeRankMoudle = new SingleGradeRankMoudle();
        singleGradeRankMoudle.setCourseName(studentCourseGrade2.getCourseName());
        singleGradeRankMoudle.setUserName(studentCourseGrade2.getUserName());
        singleGradeRankMoudle.setHighestScore(studentCourseGrade2.getHighestScore());
        singleGradeRankMoudle.setGpaRank(studentCourseGrade2.getGpaRank());
        singleGradeRankMoudle.setGpa(studentCourseGrade2.getGpa());
        return singleGradeRankMoudle;
    }

    /**
     * 删除指定学年和学期的所有相关数据。
     *
     * @param academicYear 学年，用于定位特定学年的数据。
     * @param semester     学期，用于定位特定学期的数据。
     * @return 返回操作结果，删除成功返回 "删除成功"，否则返回 "删除失败"。
     */
    @Override
    public String deleteAcademicYearSemesterMessage(String academicYear, String semester) {
        // 构建查询条件，分别删除学生课程成绩和总成绩的相关数据
        LambdaQueryWrapper<StudentCourseGrade> studentCourseGradeLambdaQueryWrapper = LambdaQueryWrapperFactory
                .getLambdaQueryWrapper(StudentCourseGrade.class);
        LambdaQueryWrapper<StudentTotalGrade> studentTotalGradeLambdaQueryWrapper = LambdaQueryWrapperFactory
                .getLambdaQueryWrapper(StudentTotalGrade.class);
        return studentCourseGradeMapper.delete(studentCourseGradeLambdaQueryWrapper
                        .eq(StudentCourseGrade::getAcademicYear, academicYear)
                        .eq(StudentCourseGrade::getSemester, semester)) > 0
                && studentTotalGradeMapper.delete(studentTotalGradeLambdaQueryWrapper
                        .eq(StudentTotalGrade::getAcademicYear, academicYear)
                        .eq(StudentTotalGrade::getSemester, semester)) > 0
                ? "删除成功" : "删除失败";
    }

    /**
     * 添加学生信息。
     *
     * @param student 学生对象，包含需要添加的学生信息。
     * @return 返回操作结果，添加成功返回 "添加成功"，否则返回 "添加失败"。
     */
    @Override
    public String addStudentMessage(Student student) {
        return studentMapper.insert(student) > 0 ? "添加成功" : "添加失败";
    }
}
